package solutions.ferpa.ztest.ent;

import java.sql.*;
import java.util.ArrayList;
import br.com.telescope.adsrt.dom.*;
import br.com.telescope.adsrt.lib.*;
import br.com.telescope.t2.exception.Severity;

/**
 * API de persistência de dados da entidade CALIBRACAO_INSTRUMENTO
 * @author Gerado pelo Telescope
 */
public class EntCalibracaoInstrumento extends Entity {
    
    public final static String ENTITY_NAME = "ZTEST.CALIBRACAO_INSTRUMENTO";
    public final static String TABLE_NAME = "CALIBRACAO_INSTRUMENTO";
    
    // <editor-fold defaultstate="collapsed" desc="Contrutores e inicializacao">
    /**
     * Construtores
     */
    public EntCalibracaoInstrumento() {
        super();
        initialize();
    }
    
    public EntCalibracaoInstrumento(BaseRuntime ctx) {
        super();
        initialize(ctx);
    }
    
    @Override
    public String getPrimaryKeyColumn() {
        return "ID";
    }
    
    @Override
    public void initialize(BaseRuntime ctx) {
        super.initialize(ctx);
        initialize();
    }
    
    public void initialize() {
        aId = new DomId(this,"ID", "Id"); 
        aId.setRequired(true);
        oId = new DomId();
        aValorReferencia = new DomDouble(this,"VALOR_REFERENCIA", "Valor de referência"); 
        aValorReferencia.setRequired(true);
        oValorReferencia = new DomDouble();
        aValorMedidoAntesAjuste = new DomDouble(this,"VALOR_MEDIDO_ANTES_AJUSTE", "Valor medido (antes ajuste)"); 
        oValorMedidoAntesAjuste = new DomDouble();
        aIncertezaMedidoAntesAjuste = new DomDouble(this,"INCERTEZA_MEDIDO_ANTES_AJUSTE", "Incerteza valor medido (antes do ajuste)"); 
        oIncertezaMedidoAntesAjuste = new DomDouble();
        aValorMedidoDepoisAjuste = new DomDouble(this,"VALOR_MEDIDO_DEPOIS_AJUSTE", "Valor medido (depois ajuste)"); 
        oValorMedidoDepoisAjuste = new DomDouble();
        aIncertezaMedidoDepoisAjuste = new DomDouble(this,"INCERTEZA_MEDIDO_DEPOIS_AJUSTE", "Incerteza valor medido (depois do ajuste)"); 
        oIncertezaMedidoDepoisAjuste = new DomDouble();
        aCertificadoCalibracaoId = new DomId(this,"CERTIFICADO_CALIBRACAO_ID", "Certificado de calibração"); 
        aCertificadoCalibracaoId.setRequired(true);
        oCertificadoCalibracaoId = new DomId();
        ressetModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributos da entidade">
    
    // Id
    private DomId aId;
    private DomId oId;
    
    // Valor de referência
    private DomDouble aValorReferencia;
    private DomDouble oValorReferencia;
    
    // Valor medido (antes ajuste)
    private DomDouble aValorMedidoAntesAjuste;
    private DomDouble oValorMedidoAntesAjuste;
    
    // Incerteza valor medido (antes do ajuste)
    private DomDouble aIncertezaMedidoAntesAjuste;
    private DomDouble oIncertezaMedidoAntesAjuste;
    
    // Valor medido (depois ajuste)
    private DomDouble aValorMedidoDepoisAjuste;
    private DomDouble oValorMedidoDepoisAjuste;
    
    // Incerteza valor medido (depois do ajuste)
    private DomDouble aIncertezaMedidoDepoisAjuste;
    private DomDouble oIncertezaMedidoDepoisAjuste;
    
    // Certificado de calibração
    private DomId aCertificadoCalibracaoId;
    private DomId oCertificadoCalibracaoId;
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ID">
    
    public EntCalibracaoInstrumento id(Long value) {
        setId(value);
        return this;
    }
    
    public void setId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyId();
        } else {
            aId.setValue(value.getValue());
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(String value) {
        if (value == null) {
            nullifyId();
        } else {
            aId.setValue(value);
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(Long value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void setId(Object value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyId() {
        if (!aId.isNull()) {
            aId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getId() {
        return aId;
    }
    
    public DomId oldId() {
        return oId;
    }
    
    public Long valueOfId() {
        return aId.getValue();
    }
    
    public boolean isIdModified() {
        return aId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo VALOR_REFERENCIA">
    
    public EntCalibracaoInstrumento valorReferencia(Double value) {
        setValorReferencia(value);
        return this;
    }
    
    public void setValorReferencia(DomDouble value) {
        if (value == null || value.isNull()) {
            nullifyValorReferencia();
        } else {
            aValorReferencia.setValue(value.getValue());
            if (aValorReferencia.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setValorReferencia(String value) {
        if (value == null) {
            nullifyValorReferencia();
        } else {
            aValorReferencia.setValue(value);
            if (aValorReferencia.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setValorReferencia(Double value) {
        aValorReferencia.setValue(value);
        if (aValorReferencia.isModified()) {
            setModified(true);
        }
    }
    
    public void setValorReferencia(Object value) {
        aValorReferencia.setValue(value);
        if (aValorReferencia.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyValorReferencia() {
        if (!aValorReferencia.isNull()) {
            aValorReferencia.setNull(true);
            setModified(true);
        }
    }
    
    public DomDouble getValorReferencia() {
        return aValorReferencia;
    }
    
    public DomDouble oldValorReferencia() {
        return oValorReferencia;
    }
    
    public Double valueOfValorReferencia() {
        return aValorReferencia.getValue();
    }
    
    public boolean isValorReferenciaModified() {
        return aValorReferencia.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo VALOR_MEDIDO_ANTES_AJUSTE">
    
    public EntCalibracaoInstrumento valorMedidoAntesAjuste(Double value) {
        setValorMedidoAntesAjuste(value);
        return this;
    }
    
    public void setValorMedidoAntesAjuste(DomDouble value) {
        if (value == null || value.isNull()) {
            nullifyValorMedidoAntesAjuste();
        } else {
            aValorMedidoAntesAjuste.setValue(value.getValue());
            if (aValorMedidoAntesAjuste.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setValorMedidoAntesAjuste(String value) {
        if (value == null) {
            nullifyValorMedidoAntesAjuste();
        } else {
            aValorMedidoAntesAjuste.setValue(value);
            if (aValorMedidoAntesAjuste.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setValorMedidoAntesAjuste(Double value) {
        aValorMedidoAntesAjuste.setValue(value);
        if (aValorMedidoAntesAjuste.isModified()) {
            setModified(true);
        }
    }
    
    public void setValorMedidoAntesAjuste(Object value) {
        aValorMedidoAntesAjuste.setValue(value);
        if (aValorMedidoAntesAjuste.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyValorMedidoAntesAjuste() {
        if (!aValorMedidoAntesAjuste.isNull()) {
            aValorMedidoAntesAjuste.setNull(true);
            setModified(true);
        }
    }
    
    public DomDouble getValorMedidoAntesAjuste() {
        return aValorMedidoAntesAjuste;
    }
    
    public DomDouble oldValorMedidoAntesAjuste() {
        return oValorMedidoAntesAjuste;
    }
    
    public Double valueOfValorMedidoAntesAjuste() {
        return aValorMedidoAntesAjuste.getValue();
    }
    
    public boolean isValorMedidoAntesAjusteModified() {
        return aValorMedidoAntesAjuste.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo INCERTEZA_MEDIDO_ANTES_AJUSTE">
    
    public EntCalibracaoInstrumento incertezaMedidoAntesAjuste(Double value) {
        setIncertezaMedidoAntesAjuste(value);
        return this;
    }
    
    public void setIncertezaMedidoAntesAjuste(DomDouble value) {
        if (value == null || value.isNull()) {
            nullifyIncertezaMedidoAntesAjuste();
        } else {
            aIncertezaMedidoAntesAjuste.setValue(value.getValue());
            if (aIncertezaMedidoAntesAjuste.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setIncertezaMedidoAntesAjuste(String value) {
        if (value == null) {
            nullifyIncertezaMedidoAntesAjuste();
        } else {
            aIncertezaMedidoAntesAjuste.setValue(value);
            if (aIncertezaMedidoAntesAjuste.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setIncertezaMedidoAntesAjuste(Double value) {
        aIncertezaMedidoAntesAjuste.setValue(value);
        if (aIncertezaMedidoAntesAjuste.isModified()) {
            setModified(true);
        }
    }
    
    public void setIncertezaMedidoAntesAjuste(Object value) {
        aIncertezaMedidoAntesAjuste.setValue(value);
        if (aIncertezaMedidoAntesAjuste.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyIncertezaMedidoAntesAjuste() {
        if (!aIncertezaMedidoAntesAjuste.isNull()) {
            aIncertezaMedidoAntesAjuste.setNull(true);
            setModified(true);
        }
    }
    
    public DomDouble getIncertezaMedidoAntesAjuste() {
        return aIncertezaMedidoAntesAjuste;
    }
    
    public DomDouble oldIncertezaMedidoAntesAjuste() {
        return oIncertezaMedidoAntesAjuste;
    }
    
    public Double valueOfIncertezaMedidoAntesAjuste() {
        return aIncertezaMedidoAntesAjuste.getValue();
    }
    
    public boolean isIncertezaMedidoAntesAjusteModified() {
        return aIncertezaMedidoAntesAjuste.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo VALOR_MEDIDO_DEPOIS_AJUSTE">
    
    public EntCalibracaoInstrumento valorMedidoDepoisAjuste(Double value) {
        setValorMedidoDepoisAjuste(value);
        return this;
    }
    
    public void setValorMedidoDepoisAjuste(DomDouble value) {
        if (value == null || value.isNull()) {
            nullifyValorMedidoDepoisAjuste();
        } else {
            aValorMedidoDepoisAjuste.setValue(value.getValue());
            if (aValorMedidoDepoisAjuste.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setValorMedidoDepoisAjuste(String value) {
        if (value == null) {
            nullifyValorMedidoDepoisAjuste();
        } else {
            aValorMedidoDepoisAjuste.setValue(value);
            if (aValorMedidoDepoisAjuste.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setValorMedidoDepoisAjuste(Double value) {
        aValorMedidoDepoisAjuste.setValue(value);
        if (aValorMedidoDepoisAjuste.isModified()) {
            setModified(true);
        }
    }
    
    public void setValorMedidoDepoisAjuste(Object value) {
        aValorMedidoDepoisAjuste.setValue(value);
        if (aValorMedidoDepoisAjuste.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyValorMedidoDepoisAjuste() {
        if (!aValorMedidoDepoisAjuste.isNull()) {
            aValorMedidoDepoisAjuste.setNull(true);
            setModified(true);
        }
    }
    
    public DomDouble getValorMedidoDepoisAjuste() {
        return aValorMedidoDepoisAjuste;
    }
    
    public DomDouble oldValorMedidoDepoisAjuste() {
        return oValorMedidoDepoisAjuste;
    }
    
    public Double valueOfValorMedidoDepoisAjuste() {
        return aValorMedidoDepoisAjuste.getValue();
    }
    
    public boolean isValorMedidoDepoisAjusteModified() {
        return aValorMedidoDepoisAjuste.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo INCERTEZA_MEDIDO_DEPOIS_AJUSTE">
    
    public EntCalibracaoInstrumento incertezaMedidoDepoisAjuste(Double value) {
        setIncertezaMedidoDepoisAjuste(value);
        return this;
    }
    
    public void setIncertezaMedidoDepoisAjuste(DomDouble value) {
        if (value == null || value.isNull()) {
            nullifyIncertezaMedidoDepoisAjuste();
        } else {
            aIncertezaMedidoDepoisAjuste.setValue(value.getValue());
            if (aIncertezaMedidoDepoisAjuste.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setIncertezaMedidoDepoisAjuste(String value) {
        if (value == null) {
            nullifyIncertezaMedidoDepoisAjuste();
        } else {
            aIncertezaMedidoDepoisAjuste.setValue(value);
            if (aIncertezaMedidoDepoisAjuste.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setIncertezaMedidoDepoisAjuste(Double value) {
        aIncertezaMedidoDepoisAjuste.setValue(value);
        if (aIncertezaMedidoDepoisAjuste.isModified()) {
            setModified(true);
        }
    }
    
    public void setIncertezaMedidoDepoisAjuste(Object value) {
        aIncertezaMedidoDepoisAjuste.setValue(value);
        if (aIncertezaMedidoDepoisAjuste.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyIncertezaMedidoDepoisAjuste() {
        if (!aIncertezaMedidoDepoisAjuste.isNull()) {
            aIncertezaMedidoDepoisAjuste.setNull(true);
            setModified(true);
        }
    }
    
    public DomDouble getIncertezaMedidoDepoisAjuste() {
        return aIncertezaMedidoDepoisAjuste;
    }
    
    public DomDouble oldIncertezaMedidoDepoisAjuste() {
        return oIncertezaMedidoDepoisAjuste;
    }
    
    public Double valueOfIncertezaMedidoDepoisAjuste() {
        return aIncertezaMedidoDepoisAjuste.getValue();
    }
    
    public boolean isIncertezaMedidoDepoisAjusteModified() {
        return aIncertezaMedidoDepoisAjuste.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo CERTIFICADO_CALIBRACAO_ID">
    
    public EntCalibracaoInstrumento certificadoCalibracaoId(Long value) {
        setCertificadoCalibracaoId(value);
        return this;
    }
    
    public void setCertificadoCalibracaoId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyCertificadoCalibracaoId();
        } else {
            aCertificadoCalibracaoId.setValue(value.getValue());
            if (aCertificadoCalibracaoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setCertificadoCalibracaoId(String value) {
        if (value == null) {
            nullifyCertificadoCalibracaoId();
        } else {
            aCertificadoCalibracaoId.setValue(value);
            if (aCertificadoCalibracaoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setCertificadoCalibracaoId(Long value) {
        aCertificadoCalibracaoId.setValue(value);
        if (aCertificadoCalibracaoId.isModified()) {
            setModified(true);
        }
    }
    
    public void setCertificadoCalibracaoId(Object value) {
        aCertificadoCalibracaoId.setValue(value);
        if (aCertificadoCalibracaoId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyCertificadoCalibracaoId() {
        if (!aCertificadoCalibracaoId.isNull()) {
            aCertificadoCalibracaoId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getCertificadoCalibracaoId() {
        return aCertificadoCalibracaoId;
    }
    
    public DomId oldCertificadoCalibracaoId() {
        return oCertificadoCalibracaoId;
    }
    
    public Long valueOfCertificadoCalibracaoId() {
        return aCertificadoCalibracaoId.getValue();
    }
    
    public boolean isCertificadoCalibracaoIdModified() {
        return aCertificadoCalibracaoId.isModified();
    }
    // </editor-fold>
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="getErrors">
    /**
     * Traduz um erro recebido do banco de dados para um AdsException
     */
    @Override
    public AdsException getErrors(String errorMsg, int transaction) {
        AdsException e;
        String msg = errorMsg.toUpperCase();
        
        if (transaction == DELETE_TRANSACTION) {
            e = new AdsException("ZTEST.CALIBRACAO_INSTRUMENTO.GET_ERRORS_UNKNOWN",
                    AdsException.UNKNOWN,
                    "Erro não esperado: " + errorMsg);
        } else {
            if (msg.indexOf("FK_CALINS_CERTIFICADO_CALIBRACAO") >= 0) {
                e = new AdsException("ZTEST.CALIBRACAO_INSTRUMENTO.FK_CALINS_CERTIFICADO_CALIBRACAO", 
                        Severity.ERROR,
                        "Registro não cadastrado para CERTIFICADO_CALIBRACAO! (FK_CALINS_CERTIFICADO_CALIBRACAO)");
                return e;
            } else if (msg.indexOf("PK_CALINS") >= 0) {
                e = new AdsException("ZTEST.CALIBRACAO_INSTRUMENTO.PK_CALINS", 
                        Severity.ERROR,
                        "ID duplicado! (PK_CALINS)");
                return e;
            } else if (msg.indexOf("UK_CALINS_VALOR_REFERENCIA_DATA") >= 0) {
                e = new AdsException("ZTEST.CALIBRACAO_INSTRUMENTO.UK_CALINS_VALOR_REFERENCIA_DATA", 
                        Severity.ERROR,
                        "Registro duplicado! Valor de referência deve ser único para o certificado de calibração deste instrumento! Certificado de calibração ${CERTIFICADO_CALIBRACAO_ID}, Valor de referência ${VALOR_REFERENCIA} (UK_CALINS_VALOR_REFERENCIA_DATA)");
                return e;
            } else {
                e = new AdsException("ZTEST.CALIBRACAO_INSTRUMENTO.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        }
        return e;
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Entity Information">
    
    public String getEntityName() {
        return ENTITY_NAME;
    }
    
    public String getTableName() {
        return TABLE_NAME;
    }
    
    public String idSequenceName() {
        return "PK_SEQUENCE";
    }
    
    private ArrayList<Field> allAttributes;
    public ArrayList<Field> getAllAttributes() {
        if (allAttributes == null) {
            allAttributes = new ArrayList<Field>();
            allAttributes.add(aId);
            allAttributes.add(aValorReferencia);
            allAttributes.add(aValorMedidoAntesAjuste);
            allAttributes.add(aIncertezaMedidoAntesAjuste);
            allAttributes.add(aValorMedidoDepoisAjuste);
            allAttributes.add(aIncertezaMedidoDepoisAjuste);
            allAttributes.add(aCertificadoCalibracaoId);
        }
        return allAttributes;
    }
    
    /**
     * Retorna o valor da primeira UK da entidade
     * Se ela for composta, retorna a concatenação de toda a combinação
     * de atributos separados por um espaço.
     */
    public String valueOfUk() {
        return getCertificadoCalibracaoId().toString() +
                " " + getValorReferencia().toString();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Relationships">
    
    
    public void findByCertificadoCalibracaoIdValorReferencia(long certificadoCalibracaoId, double valorReferencia) throws AdsException {
        findBy(new String[] {"CERTIFICADO_CALIBRACAO_ID", "VALOR_REFERENCIA"},
                new Object[] {certificadoCalibracaoId, valorReferencia});
    }
    
    private EntCertificadoCalibracao eCertificadoCalibracao;
    
    public EntCertificadoCalibracao findCertificadoCalibracao() throws AdsException {
        if (getCertificadoCalibracaoId().isNull()) {
            return null;
        }
        if (eCertificadoCalibracao == null || !valueOfCertificadoCalibracaoId().equals(eCertificadoCalibracao.valueOfId())) {
            eCertificadoCalibracao = new EntCertificadoCalibracao(ctx);
            eCertificadoCalibracao.find(valueOfCertificadoCalibracaoId());
        }
        return eCertificadoCalibracao;
    }
    
    /**
     * Ativa o join desta entidade com CERTIFICADO_CALIBRACAO
     * através do atributo CERTIFICADO_CALIBRACAO_ID
     */
    public EntCertificadoCalibracao joinCertificadoCalibracao() {
        return joinCertificadoCalibracao(null);
    }
    public EntCertificadoCalibracao joinCertificadoCalibracao(String alias) {
        EntCertificadoCalibracao entity = new EntCertificadoCalibracao(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getCertificadoCalibracaoId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByCertificadoCalibracao(long id, String sqlAppend) throws AdsException {
        find("select ID from CALIBRACAO_INSTRUMENTO where CERTIFICADO_CALIBRACAO_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByCertificadoCalibracao(long id) throws AdsException {
        findByCertificadoCalibracao(id,"");
    }
    
    public void findByCertificadoCalibracao(Entity entidade) throws AdsException {
        findByCertificadoCalibracao(entidade.valueOfId(),"");
    }
    
    public void findByCertificadoCalibracao(Entity entidade, String sqlAppend) throws AdsException {
        findByCertificadoCalibracao(entidade.valueOfId(),sqlAppend);
    }
    
    /**
     * Limpa os objetos normalizados da entidade
     */
    public void clearRelatedObjects() {
        eCertificadoCalibracao = null;
    }
    
    /**
     * Método que copia os valores dos atributos
     * para os valores respectivos old 
     */
    public void saveOldAtributes() {
        oCertificadoCalibracaoId.setValue(aCertificadoCalibracaoId);
        oValorMedidoDepoisAjuste.setValue(aValorMedidoDepoisAjuste);
        oIncertezaMedidoDepoisAjuste.setValue(aIncertezaMedidoDepoisAjuste);
        oIncertezaMedidoAntesAjuste.setValue(aIncertezaMedidoAntesAjuste);
        oValorMedidoAntesAjuste.setValue(aValorMedidoAntesAjuste);
        oValorReferencia.setValue(aValorReferencia);
        oId.setValue(aId);
    }
    
    /**
     * Método que retorna as regras da entidade
     * @return ArrayList com as regras ou null caso não existir nenhuma regra
     */
    public ArrayList getAllRules() {
        ArrayList<EntityRule> out = new ArrayList<EntityRule>();
        {
            PrimaryKeyRule rule = new PrimaryKeyRule();
            rule.setEntity(EntCalibracaoInstrumento.class);
            rule.setName("PK_CALINS");
            rule.setPkAttribute(new DomId("ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntCalibracaoInstrumento.class);
            rule.setAssociatedEntity(EntCertificadoCalibracao.class);
            rule.setName("FK_CALINS_CERTIFICADO_CALIBRACAO");
            rule.addAttribute(new DomId("CERTIFICADO_CALIBRACAO_ID",""));
            out.add(rule);
        }
        {
            UniqueKeyRule rule = new UniqueKeyRule();
            rule.setEntity(EntCalibracaoInstrumento.class);
            rule.setName("UK_CALINS_VALOR_REFERENCIA_DATA");
            rule.addAttribute(new DomDouble("VALOR_REFERENCIA",""));
            rule.addAttribute(new DomId("CERTIFICADO_CALIBRACAO_ID",""));
            out.add(rule);
        }
        return out;
    }
    // </editor-fold>
    
    @Override
    public void fillDefaultValues() throws AdsException {
        if (aId.isNull()) {
            aId.setValue("" + ctx.getNextVal("pk_sequence"));
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="Métodos customizados">
    
    /**
     * Calcular valor conforme calibração.
     * <p>
     * Calcular a correção de erro.
     */
    public double calcularValorConformeCalibracao() throws AdsException {
        // <user-code id="20655352" parentId="20655348" hashcode="-29bc385b" length="12">
        return -1.0;
        // </user-code>
    }
}
